package Conecciondb;
import java.sql.Connection;
import java.sql.Statement;
import java.sql.ResultSet;
import java.sql.DriverManager;
import java.sql.SQLWarning;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
import javax.swing.JOptionPane;


/**
 * Clase para la conexion con la base de datos
 * @author Elesdoar
 */
public class ConexionDb implements Cloneable 
{
	private Connection con;
    private Statement stmt;
    private ResultSet rs;
    private String database = "eledubd";
    private String password = "unaleledu";
    private String user = "eledubd";
    
    private static boolean DEBUG;   
   
    /**
     * Constructor de la clase, establece la coneccion con la base de datos MySQL
     */
	public ConexionDb() throws SQLException, Exception
    {
        DEBUG = true;
        if (revisarDriverMy())
         abrirConexion("jdbc:mysql://www.hostingaldia.com/"+this.database
                 +"?user="+this.user+"&password="+this.password);
        else
          JOptionPane.showMessageDialog(null, "No se pudo establecer la coneccion con la base de datos"
                    , "Error de Conexion", JOptionPane.ERROR_MESSAGE);
    }
    
    /**
     * Revisa si hay conexion con la base de datos
     * @return True si no hay ningun problema con el driver, ni error al conectarse.
     */

    private boolean revisarDriverMy() 
    {
        boolean fg = true;
        try {
            Class.forName ("org.gjt.mm.mysql.Driver").newInstance();
            if(DEBUG)
             System.out.println ("\n*** Utilizando driver de MySql ***\n");
        }
        catch(InstantiationException ex1)
        {
        	fg = false;
        }
        catch(IllegalAccessException ex2)
        {
        	fg = false;
        }
        catch (ClassNotFoundException ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Sun ClassNotFoundException interceptado ***\n");
            	System.err.println(ex);
            }
            fg = false;
        }
        return fg;
    }

    /**
     * Abre la conexion con la base de datos
     *
     * @param url Direccion donde esta alojada la base de datos
     * @param log Nombre de Usuario de la base de datos
     * @param pass Password
     */
    private void abrirConexion(String url,String log,String pass)
     throws SQLException, Exception
    {
          // DriverManager.setLogStream(System.out);
          // Intenta conectarse al Driver. Cada uno de
          // los drivers registrados ser n cargados hasta
          // que se encuentre el que pueda procesar la url
          // especificada
          con = DriverManager.getConnection(url, log, pass);
          // Si no es posible conectarse, se generar  un error
          // que podr¡a ser identificada. De lo contrario, si obtiene
          // la URL se conectar  satisfactoriamente.
          // Checa y despliega los mensajes generados por la conexi¢n
          checkForWarning (con.getWarnings ());
          // Obtiene el objeto DatabaseMetaData y despliega
          // Informaci¢n acerca de la conexi¢n.
          DatabaseMetaData dma = con.getMetaData ();
          if(DEBUG)
          {
          	System.out.println("\nConectado a " + dma.getURL());
          	System.out.println("Driver       " + dma.getDriverName());
          	System.out.println("Versi¢n      " + dma.getDriverVersion());
          	System.out.println("");
          }
          // Crea el objeto Statement para poder introducir
          // instrucciones de SQL al driver
          stmt = con.createStatement ();        
        /*catch (SQLException ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Error de SQL interceptado ***\n");
            	while (ex != null) {
              		System.out.println ("SQLState: " + ex.getSQLState ());
              		System.out.println ("Mensaje:  " + ex.getMessage ());
              		System.out.println ("Error:   " + ex.getErrorCode ());
              		ex = ex.getNextException ();
              		System.out.println ("");
            	}
            }
        }
        catch (Exception ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Exception interceptado ***\n");
            	ex.printStackTrace ();
            }
        }*/
    }

    /**
     * Abre la conexion con la base de datos
     *
     * @param url Direccion del host de la base de datos con usuario y contraseña
     */
    private void abrirConexion(String url)
    {
        try {
          // DriverManager.setLogStream(System.out);
          // Intenta conectarse al Driver. Cada uno de
          // los drivers registrados ser n cargados hasta
          // que se encuentre el que pueda procesar la url
          // especificada
          con = DriverManager.getConnection(url);
          // Si no es posible conectarse, se generar  un error
          // que podr¡a ser identificada. De lo contrario, si obtiene
          // la URL se conectar  satisfactoriamente.
          // Checa y despliega los mensajes generados por la conexi¢n
          checkForWarning (con.getWarnings ());
          // Obtiene el objeto DatabaseMetaData y despliega
          // Informaci¢n acerca de la conexi¢n.
          DatabaseMetaData dma = con.getMetaData ();
          if(DEBUG)
          {
          	System.out.println("\nConectado a " + dma.getURL());
          	System.out.println("Driver       " + dma.getDriverName());
          	System.out.println("Versi¢n      " + dma.getDriverVersion());
          	System.out.println("");
          }
          // Crea el objeto Statement para poder introducir
          // instrucciones de SQL al driver
          stmt = con.createStatement ();
        }
        catch (SQLException ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Error de SQL interceptado ***\n");
            	while (ex != null) {
              		System.out.println ("SQLState: " + ex.getSQLState ());
              		System.out.println ("Mensaje:  " + ex.getMessage ());
              		System.out.println ("Error:   " + ex.getErrorCode ());
              		ex = ex.getNextException ();
              		System.out.println ("");
            	}
            }
            JOptionPane.showMessageDialog(null, "No se pudo establecer la coneccion con la base de datos"
                    , "Error de Conexion", JOptionPane.ERROR_MESSAGE);
        }
        catch (Exception ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Exception interceptado ***\n");
            	ex.printStackTrace ();
            }
            JOptionPane.showMessageDialog(null, "No se pudo establecer la coneccion con la base de datos"
                    , "Error de Conexion", JOptionPane.ERROR_MESSAGE);
        }
    }

    /**
     * Si es dado un objeto de SQLWarning, despliega los
     * mensajes de advertencia. Note que pueden existir múltiples
     * mensajes que podrían estar encadenados
     * @param warn Objeto SQLWarning
     * @return True si hay algun warning
     * @throws java.sql.SQLException
     */

    private static boolean checkForWarning (SQLWarning warn) throws SQLException
    {
        boolean rc = false;    

        if (warn != null) {
            rc = true;
            if(DEBUG)
            {
            	System.out.println ("\n *** Advertencia ***\n");            	
            	while (warn != null) {
                	System.out.println ("SQLState: " + warn.getSQLState ());
                	System.out.println ("Mensaje:  " + warn.getMessage ());
                	System.out.println ("Error:   " + warn.getErrorCode ());
                	System.out.println ("");
                	warn = warn.getNextWarning ();
            	}
            }
        }
        return rc;
    }

    /**
     * Ejecuta sentencias SQL que actualicen o modifiquen la base de datos,
     * INSERT, UPDATE, DELETE
     * @param query Sentencia SQL
     * @return True si la sentencia se ejecuta correctamente
     */
    public boolean insert(String query)
    {
        try
        {
        	int n = stmt.executeUpdate (query);
            return true;
		}
		catch (SQLException ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Error de SQL interceptado ***\n");
            	while (ex != null) {
              		System.out.println ("SQLState: " + ex.getSQLState ());
              		System.out.println ("Mensaje:  " + ex.getMessage ());
              		System.out.println ("Error:   " + ex.getErrorCode ());
              		ex = ex.getNextException ();
              		System.out.println ("");
            	}
            }
        }
        catch (Exception ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Exception interceptado ***\n");
            	ex.printStackTrace ();
            }
        }
        return false;
    }

    /**
     * Ejecuta un SELECT en la base de datos
     * @param query Sentencia SQL
     * @return Retorna las filas devueltas por la setencia SQL o null en caso de que no
     *         hayan resuntados
     */
    public ResultSet select(String query)
    {
    	try
    	{
    		rs = stmt.executeQuery (query);
    		if(rs.next())
    		 return rs;
    	}
    	catch (SQLException ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Error de SQL interceptado ***\n");
            	while (ex != null) {
              		System.out.println ("SQLState: " + ex.getSQLState ());
              		System.out.println ("Mensaje:  " + ex.getMessage ());
              		System.out.println ("Error:   " + ex.getErrorCode ());
              		ex = ex.getNextException ();
              		System.out.println ("");
            	}
            }
        }
        catch (Exception ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Exception interceptado ***\n");
            	ex.printStackTrace ();
            }
        }
        return null;
    }

    public ResultSet select1(String query)
    {
    	try
    	{
    		rs = stmt.executeQuery (query);
    		if(rs.next())
    		 return con.createStatement().executeQuery (query);
    	}
    	catch (SQLException ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Error de SQL interceptado ***\n");
            	while (ex != null) {
              		System.out.println ("SQLState: " + ex.getSQLState ());
              		System.out.println ("Mensaje:  " + ex.getMessage ());
              		System.out.println ("Error:   " + ex.getErrorCode ());
              		ex = ex.getNextException ();
              		System.out.println ("");
            	}
            }
        }
        catch (Exception ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Exception interceptado ***\n");
            	ex.printStackTrace ();
            }
        }
        return null;
    }

    /**
     * Cierra la conexion establecida con la base de datos
     */
    public void close()
    {
    	try
    	{
    		con.close();
    	}
    	catch (SQLException ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Error de SQL interceptado ***\n");
            	while (ex != null) {
              		System.out.println ("SQLState: " + ex.getSQLState ());
              		System.out.println ("Mensaje:  " + ex.getMessage ());
              		System.out.println ("Error:   " + ex.getErrorCode ());
              		ex = ex.getNextException ();
              		System.out.println ("");
            	}
            }
        }
        catch (Exception ex) {
            if(DEBUG)
            {
            	System.out.println ("\n*** Exception interceptado ***\n");
            	ex.printStackTrace ();
            }
        }
    }


}